const db = uniCloud.database();
const courseCollection = db.collection('course');

module.exports = {
  _before: function() {
    // 通用前置处理
  },
  
  /**
   * 获取课程列表
   * @param {Object} params - 查询参数
   * @param {String} params.name - 课程名称（可选）
   * @param {Number} params.status - 状态（可选）
   * @param {Number} params.page - 页码
   * @param {Number} params.pageSize - 每页数量
   * @returns {Object} 课程列表和总数
   */
  async getCourseList(params = {}) {
    const { name, status, page = 1, pageSize = 10 } = params;
    
    // 构建查询条件
    const query = {};
    if (name) query.name = new RegExp(name, 'i');
    if (status !== undefined) query.status = status;
    
    // 查询总数
    const countResult = await courseCollection.where(query).count();
    const total = countResult.total;
    
    // 查询分页数据
    const list = await courseCollection
      .where(query)
      .skip((page - 1) * pageSize)
      .limit(pageSize)
      .orderBy('create_date', 'desc')
      .get()
      .then(res => res.data);
    
    return {
      list,
      total,
      page,
      pageSize
    };
  },
  
  /**
   * 获取课程详情
   * @param {String} id - 课程ID
   * @returns {Object} 课程详情
   */
  async getCourseDetail(id) {
    if (!id) throw new Error('课程ID不能为空');
    
    const course = await courseCollection.doc(id).get().then(res => res.data[0]);
    if (!course) throw new Error('课程不存在');
    
    return course;
  },
  
  /**
   * 创建课程
   * @param {Object} data - 课程数据
   * @returns {Object} 创建结果
   */
  async createCourse(data) {
    // 验证数据
    const { name, start_date, end_date, weekdays, time, fee, fee_type } = data;
    if (!name) throw new Error('课程名称不能为空');
    if (!start_date) throw new Error('开始日期不能为空');
    if (!end_date) throw new Error('结束日期不能为空');
    if (!weekdays || !Array.isArray(weekdays) || weekdays.length === 0) {
      throw new Error('上课日不能为空');
    }
    if (!time) throw new Error('上课时间不能为空');
    if (fee === undefined) throw new Error('收费金额不能为空');
    if (![1, 2].includes(fee_type)) throw new Error('收费方式不正确');
    
    // 验证日期
    const startDate = new Date(start_date);
    const endDate = new Date(end_date);
    if (startDate > endDate) {
      throw new Error('开始日期不能晚于结束日期');
    }
    
    // 验证上课日
    for (const day of weekdays) {
      if (![1, 2, 3, 4, 5, 6, 7].includes(day)) {
        throw new Error('上课日格式不正确，应为1-7的数字，表示周一至周日');
      }
    }
    
    // 验证按次收费时必须有次数
    if (fee_type === 2 && !data.fee_count) {
      throw new Error('按次收费时必须设置收费次数');
    }
    
    // 创建课程
    const result = await courseCollection.add({
      ...data,
      status: data.status || 1,
      create_date: new Date(),
      update_date: new Date()
    });
    
    return {
      id: result.id,
      success: true
    };
  },
  
  /**
   * 更新课程
   * @param {String} id - 课程ID
   * @param {Object} data - 更新数据
   * @returns {Object} 更新结果
   */
  async updateCourse(id, data) {
    if (!id) throw new Error('课程ID不能为空');
    
    // 检查日期
    if (data.start_date && data.end_date) {
      const startDate = new Date(data.start_date);
      const endDate = new Date(data.end_date);
      if (startDate > endDate) {
        throw new Error('开始日期不能晚于结束日期');
      }
    }
    
    // 验证上课日
    if (data.weekdays) {
      for (const day of data.weekdays) {
        if (![1, 2, 3, 4, 5, 6, 7].includes(day)) {
          throw new Error('上课日格式不正确，应为1-7的数字，表示周一至周日');
        }
      }
    }
    
    // 验证按次收费时必须有次数
    if (data.fee_type === 2 && !data.fee_count) {
      throw new Error('按次收费时必须设置收费次数');
    }
    
    // 更新课程
    await courseCollection.doc(id).update({
      ...data,
      update_date: new Date()
    });
    
    return {
      id,
      success: true
    };
  },
  
  /**
   * 更新课程状态
   * @param {String} id - 课程ID
   * @param {Number} status - 状态：1 激活，0 停用
   * @returns {Object} 更新结果
   */
  async updateCourseStatus(id, status) {
    if (!id) throw new Error('课程ID不能为空');
    if (![0, 1].includes(status)) throw new Error('状态值不正确');
    
    await courseCollection.doc(id).update({
      status,
      update_date: new Date()
    });
    
    return {
      id,
      success: true
    };
  },
  
  /**
   * 删除课程
   * @param {String} id - 课程ID
   * @returns {Object} 删除结果
   */
  async deleteCourse(id) {
    if (!id) throw new Error('课程ID不能为空');
    
    // 检查是否有关联的报名记录
    const enrollmentCount = await db.collection('enrollment')
      .where({ course_id: id, status: 1 })
      .count();
    
    if (enrollmentCount.total > 0) {
      throw new Error('该课程有关联的报名记录，无法删除');
    }
    
    await courseCollection.doc(id).remove();
    
    return {
      id,
      success: true
    };
  },
  
  /**
   * 获取所有激活课程，用于下拉选择
   * @returns {Array} 课程列表
   */
  async getActiveCourses() {
    return await courseCollection
      .where({ status: 1 })
      .field({ _id: true, name: true, fee: true, fee_type: true, fee_count: true })
      .orderBy('create_date', 'desc')
      .get()
      .then(res => res.data);
  },
  
  /**
   * 根据ID批量获取课程
   * @param {Array} ids - 课程ID数组
   * @returns {Array} 课程列表
   */
  async getCoursesByIds(ids) {
    if (!ids || !Array.isArray(ids) || ids.length === 0) {
      return [];
    }
    
    return await courseCollection
      .where({
        _id: db.command.in(ids)
      })
      .get()
      .then(res => res.data);
  }
}; 